Towards a canonical classical natural deduction system

This paper studies a new classical natural deduction system, presented as a typed calculus named \lml. It is designed to be isomorphic to Curien-Herbelin's calculus, both at the level of proofs and reduction, and the isomorphism is based on the correct correspondence between cut (resp. left-introduction) in sequent calculus, and substitution (resp. elimination) in natural deduction. It is a combination of Parigot's $\lambda\mu$-calculus with the idea of ``coercion calculus'' due to Cervesato-Pfenning, accommodating let-expressions in a surprising way: they expand Parigot's syntactic class of named terms. This calculus aims to be the simultaneous answer to three problems. The first problem is the lack of a canonical natural deduction system for classical logic. \lml is not yet another classical calculus, but rather a canonical reflection in natural deduction of the impeccable treatment of classical logic by sequent calculus. The second problem is the lack of a formalization of the usual semantics of Curien-Herbelin's calculus, that explains co-terms and cuts as, respectively, contexts and hole-filling instructions. The mentioned isomorphism is the required formalization, based on the precise notions of context and hole-expression offered by \lml. The third problem is the lack of a robust process of ``read-back'' into natural deduction syntax of calculi in the sequent calculus format, that affects mainly the recent proof-theoretic efforts of derivation of $\lambda$-calculi for call-by-value. An isomorphic counterpart to the $Q$-subsystem of Curien-Herbelin's-calculus is derived, obtaining a new $\lambda$-calculus for call-by-value, combining control and let-expressions.Fundação para a Ciência e a Tecnologia (FCT

Type-Safe Method Inlining

In a typed language such as Java, inlining of virtual methods does not always preserve typability. The best known solution to this problem is to insert type casts, which may hurt performance. This paper presents a solution that never hurts performance. The solution is based on a transformation that modifies static type annotations and changes some virtual calls into static calls, which can then be safely inlined

Fast Escape Analysis and Stack Allocation for Object-Based Programs

A fast and scalable interprocedural escape analysis algorithm is presented The analysis com putes a description of a subset of created objects whose lifetim e is bounded by the lifetim e of a runtim e stack fram e The analysis results can be used for m ny purposes, including stack allocation of objects, thread synchronization elim ination, deadstore rem oval, codem otion, and iterator reduction Am ethod to use the analysis results for transform ing a program to allocatesom e objects on the runtim e stack is also presented For non-trivial program s, typically 10%-20% of all allocated objects are placed on the runtim e stack after the transformG)]G

Solving Regular Tree Grammar Based Constraints

This paper describes the precise specification, design, analysis, implementation, and measurements of an efficient algorithm for solving regular tree grammar based constraints. The particular constraints are for dead-code elimination on recursive data, but the method used for the algorithm design and complexity analysis is general and applies to other program analysis problems as well. The method is centered around Paige's finite dierencing, i.e., computing expensive set expressions incrementally, and allows the algorithm to be derived and analyzed formally and implemented easily. We propose higher-level transformations that make the derived algorithm concise and allow its complexity to be analyzed accurately. Although a rough analysis shows that the worst-case time complexity is cubic in program size, an accurate analysis shows that it is linear in the number of live program points and in other parameters, including mainly the arity of data constructors and the number of selector applications into whose arguments the value constructed at a program point might flow. These parameters explain the performance of the analysis in practice. Our implementation also runs two to ten times as fast as a previous implementation of an informally designed algorithm